Welcome to this session of the seminar! In the last weeks you might have seen, that the visualisation of networks is not as easy as it may seem. This is due to the fact, that it is quite difficult to sensefully map 3D Information in a two dimensional space. The content of this chapter is deeply inspired by the materials by Katherine Ognyanova (2024) and (Rawlings et al. 2023).
library(needs)
needs(tidygraph,
ggraph,
igraph,
ggplot2,
dplyr,
gganimate,
networkD3,
dplyr,
tidyr,
tibble,
stringr,
gridExtra,
htmlwidgets,
intergraph
)
setwd("C:/Users/ls68bino/Documents/GitHub/SGrehl.github.io/computational-social-sciences") When we design a network visualization, like almost always we first need to think about the purpose of the visualization. What are the structural features we want to show? What do we want to communicate?
Most of the time, we will want to show a combination of these features.
When we talk about network visualisation, there are different forms of representation, that we can use. The most common we call network maps, a visualitsation of the nodes and edges in a two-dimensional space. But we can use other forms of representation as well, like
Today we will focus mostly on network maps.
When mapping networks we have different design-elements, that we can use to represent the nodes and edges. The most common are: Color, Position, Size, Shape and Position as well as labels.
Colors are extremely useful in plotting to differentiate between types of objects or different values of variabes.
Colors can be called by using either named colors, hex or RGB values.
In base R, we can plot by defining point coordinates, symbol shapes, point size and color:
plot(x=1:10,
y=rep(5,10),
pch=20,
cex=3,
col="lavender")
points(x=1:10,
y=rep(6, 10),
pch=1,
cex=3,
col="#B43757"
)
points(x=1:10,
y=rep(4, 10),
pch=7,
cex=3,
col=rgb(175, 105, 238, maxColorValue=255)
)
We can also set the the opacity of our colors by using alpha in rgb. The alpha value can be set between 0 (transparent) and 1 (opaque).
plot(x=1:5,
y=rep(5,5),
pch=19,
cex=12,
col=rgb(.25, .5, .3, alpha=.5),
xlim=c(0,6)
) 
In a hex color representation, we can use adjustcolor() to adjust the color brightness.
col.tr <- grDevices::adjustcolor("#B43757",
alpha=0.2)
plot(x=1:5,
y=rep(5,5),
pch=19, cex=12,
col=col.tr,
xlim=c(0,6)
)
You can use built-in R colors by using the command colors().
Sometimes we need a number of contrastiing colors. We can use predefined color palettes or the RColorBrewer package.
par(bg="white")
pal1 <- heat.colors(5,
alpha=1
) # 5 colors from the heat palette, opaque
pal2 <- rainbow(5,
alpha=.5
) # 5 colors from the heat palette, transparent
plot(x=1:10,
y=1:10,
pch=19,
cex=5,
col=pal1
)
par(mfrow = c(4, 1)
) # Set up the plotting area to have 3 rows and 1 column
plot(x=1:10,
y=1:10,
pch=19,
cex=5,
col=pal2
)
# Generate our own palette and plot
palf <- colorRampPalette(c("lavender",
"lightblue")
)
plot(x=1:10,
y=1:10,
pch=19,
cex=5,
col=palf(10)
)
palf <- colorRampPalette(c(rgb(1,1,1, .2),
rgb(.8,0,0, .7)),
alpha=TRUE)
plot(x=10:1,
y=1:10,
pch=19,
cex=5,
col=palf(10)
)
library(RColorBrewer)
display.brewer.all() # shows all palettes
par(mfrow = c(1, 1)) # Reset the plotting area to default
Remember the twin-city network, you created in the last Übungsblatt? We will use it again to day in order to show the different options we have in plotting.
twin_cities <- readRDS("Übungsblätter/Data/twin_cities.rds")
tc_transform <- twin_cities |>
enframe() |>
unnest_wider("value") |>
unnest(c(cities, countries)) |>
mutate(
cities = str_replace(cities, "Addis Ababa", "Addis_Abeba"),
cities = str_replace(cities, "Frankfurt am Main", "Frankfurt_am_Main"),
cities = str_replace(cities, "Ho Chi Minh City", "Ho_Chi_Minh_Stadt"),
cities = str_replace(cities, "Kyiv", "Kyjiw"),
cities = str_replace(cities, "Nanjing", "Nanjing"),
cities = str_replace(cities, "Kraków", "Krakau")
)
d1 <- tibble(
city = c(
"Addis_Abeba",
"Birmingham",
"Bologna",
"Brünn",
"Frankfurt_am_Main",
"Hannover",
"Herzliya",
"Ho_Chi_Minh_Stadt",
"Houston",
"Krakau",
"Kyjiw",
"Lyon",
"Nanjing",
"Thessaloniki",
"Travnik"
),
country = c(
"Ethiopia",
"United Kingdom",
"Italy",
"Czech Republic",
"Germany",
"Germany",
"Israel",
"Vietnam",
"United States",
"Poland",
"Ukraine",
"France",
"China",
"Greece",
"Bosnia and Herzegovina"
)
) |>
rename(
cities = city,
countries = country
)
vertices <- tc_transform |>
select(-name) |>
rbind(d1) |>
distinct(cities, .keep_all = T)
edgelist <- tc_transform |>
select(-countries) |>
rename(
from = name,
to = cities
)
twin_cities <- graph_from_data_frame(d = edgelist,
directed = FALSE,
vertices = vertices)
twin_cities <- igraph::simplify(twin_cities,
remove.multiple = TRUE,
remove.loops = TRUE)By default, igraph plots the network like this:
igraphAs we can clearly see, it is really difficult to identify any nodes or edges, and especially any structure within the network. But already with a few lines of code, we can improve the visualization a lot and make structural metrics more obvious.
Lets have a look at the (most important) different options:
| Parameter | Description |
|---|---|
| NODES | |
| vertex.color | Node color |
| vertex.frame.color | Node border color |
| vertex.shape | Node shape options include “none”, “circle”, “square”, “csquare”, “rectangle”, “crectangle”, “vrectangle”, “pie”, “raster”, or “sphere” |
| vertex.size | Size of the node (default is 15) |
| vertex.size2 | Second size of the node (e.g., for a rectangle) |
| vertex.label | Character vector used to label the nodes |
| vertex.label.family | Font family of the label (e.g., “Times”, “Helvetica”) |
| vertex.label.font | Font: 1 plain, 2 bold, 3 italic, 4 bold italic, 5 symbol |
| vertex.label.cex | Font size (multiplication factor, device-dependent) |
| vertex.label.dist | Distance between the label and the vertex |
| vertex.label.degree | Position of the label in relation to the vertex, where 0 is right, “pi” is left, “pi/2” is below, and “-pi/2” is above |
| EDGES | |
| edge.color | Edge color |
| edge.width | Edge width, defaults to 1 |
| edge.arrow.size | Arrow size, defaults to 1 |
| edge.arrow.width | Arrow width, defaults to 1 |
| edge.lty | Line type options: 0 or “blank”, 1 or “solid”, 2 or “dashed”, 3 or “dotted”, 4 or “dotdash”, 5 or “longdash”, 6 or “twodash” |
| edge.label | Character vector used to label edges |
| edge.label.family | Font family of the label (e.g., “Times”, “Helvetica”) |
| edge.label.font | Font: 1 plain, 2 bold, 3 italic, 4 bold italic, 5 symbol |
| edge.label.cex | Font size for edge labels |
| edge.curved | Edge curvature, range 0-1 (FALSE sets it to 0, TRUE to 0.5) |
| arrow.mode | Vector specifying arrow presence: 0 no arrow, 1 back, 2 forward, 3 both |
| OTHER | |
| margin | Empty space margins around the plot, vector with length 4 |
| frame | If TRUE, the plot will be framed |
| main | Adds a title to the plot if set |
| sub | Adds a subtitle to the plot if set |
| asp | Aspect ratio of the plot (y/x), numeric |
| palette | Color palette to use for vertex color |
| rescale | Whether to rescale coordinates to [-1,1], default is TRUE |
There are two ways to define the attributes for a plot. We can either define them directly in the plot prompt or add the information to the igraph-object directly.
# Option 1:
plot(twin_cities,
edge.arrow.size=.2,
edge.color="lavender",
vertex.color="lavender",
vertex.frame.color="#ffffff",
vertex.label.color="black",
vertex.label.cex = 0.5,
vertex.cex = 3
)
or:
tc <- twin_cities
leipzig_vertex <- which(V(tc)$name == "Leipzig") # Find the index of Leipzig
# Calculate shortest path distances from Leipzig to all other nodes
distances <- distances(tc, v = leipzig_vertex)
# Färbe die Knoten basierend auf der Entfernung von Leipzig
V(tc)$color[distances == 1] <- "lightblue" # Wenn Abstand 1, Farbe "lightblue"
V(tc)$color[distances == 2] <- "lightcyan" # Wenn Abstand 2, Farbe "lightcyan"
V(tc)$size <- 4
V(tc)$label <- NA
E(tc)$edge.color <- "gray80"
plot(tc)
legend(x="bottomleft",
c("dist = 1","dist = 2"),
pch=21,
col="#777777",
pt.bg=c("lightblue", "lightcyan"),
pt.cex=2,
cex=.8,
bty="n",
ncol=1)
or we can only plot names (this time for a subset of nodes for visibility)
summary(V(tc)$color)
V(tc)$color[V(tc)$name == "Leipzig"] <- "lightblue"
lightblue_nodes <- V(tc)[which(V(tc)$color == "lightblue")]
V(tc)$label <- V(tc)$name
# Create the subgraph with those nodes
lightblue_subgraph <- induced_subgraph(tc, lightblue_nodes)
# called aus irgendeinem grund das falsche igraph - so gehts
lightblue_subgraph <- igraph::simplify(lightblue_subgraph,
remove.multiple = TRUE,
remove.loops = TRUE)
plot(lightblue_subgraph,
vertex.shape="none",
vertex.label=V(lightblue_subgraph)$name,
vertex.label.font=2,
vertex.label.color="gray40",
vertex.label.cex=.7,
edge.color="gray85"
)
and then again we can overwrite attributes in the plot directly.
The package igraph offers a variety of layouts. Depending on the size of the network, we can already see a lot of differences in the plot by changing the layout. The default value is layout_nicely, a smart function that chooses a layouter based on the graph.
V(twin_cities)$size <- 5
V(twin_cities)$frame.color <- "white"
V(twin_cities)$color <- "lightblue"
V(twin_cities)$label <- ""
E(twin_cities)$arrow.mode <- 0
plot(twin_cities)
Igraph has a lot of built in layouts that are either a function or a numeric matrix, that specify how the vertices will be placed in a plot.
If it is a numeric matrix, then the matrix has to have one line for each vertex, specifying its coordinates. The matrix should have at least two columns, for the x and y coordinates, and it can also have third column, this will be the z coordinate for 3D plots and it is ignored for 2D plots.
If a two column matrix is given for the 3D plotting function rglplot then the third column is assumed to be 1 for each vertex.
plot(twin_cities,
layout = layout_in_circle)
plot(twin_cities,
layout=layout_on_sphere)If layout is a function, this function will be called with the graph as the single parameter to determine the actual coordinates. The function should return a matrix with two or three columns. For the 2D plots the third column is ignored.
The Fruchterman-Reingold algorithm is a popular force-directed layout method. It simulates a physical system where nodes act as repelling particles and edges as attracting springs. This results in a graph where nodes are evenly distributed, with more connected nodes closer together. However, it can be slow and is typically not used for graphs larger than ~1000 vertices.
plot(twin_cities,
layout=layout_with_fr)With force-directed layouts we can use the niter parameter to control the number of iterations to perdorm. The default is set at 500.
plot(twin_cities,
layout=layout_with_fr(twin_cities,
niter=50)
)
By default, plot coordinates are rescaled to the [-1, 1] interval. To adjust this, set rescale=FALSE and manually rescale the plot using a scalar. You can also use norm_coords to normalize the plot within custom boundaries for a more compact or spread-out layout.
l <- layout_with_fr(twin_cities) # save coordinates so layout is not recalculated
# Normalize coordinates to custom boundaries
l <- norm_coords(l, ymin=-1, ymax=1, xmin=-1, xmax=1)
# Set up plot grid
par(mfrow=c(2,2), mar=c(0,0,0,0))
# Plot with varying layouts
plot(twin_cities, rescale=FALSE, layout=l*0.4)
plot(twin_cities, rescale=FALSE, layout=l*0.6)
plot(twin_cities, rescale=FALSE, layout=l*0.8)
plot(twin_cities, rescale=FALSE, layout=l*1.0)
The Kamada-Kawai algorithm is another force-directed algorithm that minimizes the energy in a spring system.
plot(twin_cities,
layout=layout_with_kk)
The graphopt layout algorithm allows customization of physical simulation parameters that influence the resulting graph layout. You can adjust:
charge — the electric repulsion between nodes (default: 0.001)mass — the mass of each node, affecting movement (default: 30)spring.length — the ideal edge length (default: 0)spring.constant — the stiffness of the springs (default: 1)Tweaking these parameters can produce significantly different layouts by changing how nodes repel or attract each other.
# The charge parameter below changes node repulsion:
l1 <- layout_with_graphopt(twin_cities, charge=0.02)
l2 <- layout_with_graphopt(twin_cities, charge=0.00000001)
par(mfrow=c(1,2), mar=c(1,1,1,1))
plot(twin_cities, layout=l1)
plot(twin_cities, layout=l2)
The MDS (Multidimensional Scaling) layout positions nodes based on a distance or similarity measure. By default, it uses shortest path distances, placing more similar nodes closer together. You can also supply a custom distance matrix using the dist parameter. MDS layouts are useful because node positions reflect actual distances, giving the layout a clear geometric interpretation. However, visual clarity can suffer — nodes may overlap or cluster too tightly.
plot(twin_cities,
layout = layout_with_mds)So there are a lot of different ways to plot networks - highlighting different structural properties to the visual analysis (or description).
# Get all layout functions, except the first (which is usually NULL) and bipartite layouts
layouts <- grep("^layout_", ls("package:igraph"), value = TRUE)[-1]
layouts <- layouts[!grepl("bipartite", layouts)]
# Folder to save plots
dir.create("Graphics/layouts", showWarnings = FALSE)
# Plot and save each layout
for (layout in layouts) {
layout_fun <- get(layout, asNamespace("igraph"))
l <- layout_fun(twin_cities)
png(filename = paste0("Graphics/layouts/", layout, ".png"), width = 800, height = 800)
plot(twin_cities,
edge.arrow.mode = 0,
layout = l,
main = layout)
dev.off()
}
# Start Quarto block
cat("::: {layout-ncol=4}\n\n")
# Print each image markdown
for (layout in layouts) {
cat(sprintf('{group="distribution"}\n\n', layout))
}
# End Quarto block
cat(":::\n")
This plot visualizes how far each city is from Leipzig in terms of network distance. A lavender-to-blue gradient is used, where cities closer to Leipzig appear darker and those further away appear lighter. The path distance to Leipzig is added as a vertex.label.
lavender_palette <- colorRampPalette(c("#6A5ACD", "#E6E6FA")) # purple to lavender
dist.from.Leipzig <- distances(twin_cities,
v = V(twin_cities)[name == "Leipzig"],
to = V(twin_cities),
weights = NA)
col <- lavender_palette(max(dist.from.Leipzig) + 1)
col <- col[dist.from.Leipzig + 1]
plot(twin_cities,
vertex.color = col,
vertex.label = dist.from.Leipzig,
edge.arrow.size = 0.6,
vertex.label.color = "black",
vertex.label.size = 0.3)
This visualization highlights the shortest path between Leipzig and Kyoto to emphasize both the nodes and the edges involved in the path.
city_path <- shortest_paths(twin_cities,
from = V(twin_cities)[name == "Leipzig"],
to = V(twin_cities)[name == "Kyoto"],
output = "both")
ecol <- rep("gray80", ecount(twin_cities))
ecol[unlist(city_path$epath)] <- "#9370DB" # medium purple
vcol <- rep("gray40", vcount(twin_cities))
vcol[unlist(city_path$vpath)] <- "#D8BFD8" # thistle (light purple)
plot(twin_cities,
vertex.color = vcol,
edge.color = ecol,
edge.width = 0.1
)
This figure highlights all edges that are directly connected to Leipzig. The city itself is shown in purple, and its incident connections are marked in blue.
inc.edges <- incident(twin_cities,
V(twin_cities)[name == "Leipzig"],
mode = "all")
ecol <- rep("gray80", ecount(twin_cities))
ecol[inc.edges] <- "#6495ED" # cornflower blue
vcol <- rep("gray40", vcount(twin_cities))
vcol[V(twin_cities)$name == "Leipzig"] <- "#BA55D3" # medium orchid
plot(twin_cities,
vertex.color = vcol,
edge.color = ecol)
This network highlights the immediate neighbors of Leipzig—cities directly connected by an outgoing edge.
neigh.nodes <- neighbors(twin_cities,
V(twin_cities)[name == "Leipzig"],
mode = "out")
vcol <- rep("gray40", vcount(twin_cities))
vcol[neigh.nodes] <- "#87CEFA" # light sky blue
vcol[V(twin_cities)$name == "Leipzig"] <- "#BA55D3" # medium orchid
plot(twin_cities,
vertex.color = vcol)
These two side-by-side plots mark groups of cities based on their country attribute (France or Japan) - this will make more sense once we dive into the community detection algorithms next week :)
# **Mark country groups (France and Japan) with lavender-blue tones**
france_nodes <- which(V(twin_cities)$countries == "France")
japan_nodes <- which(V(twin_cities)$countries == "Japan")
par(mfrow = c(1, 2))
plot(twin_cities,
mark.groups = france_nodes,
mark.col = "#E6E6FA", # lavender
mark.border = NA)
plot(twin_cities,
mark.groups = list(france_nodes, japan_nodes),
mark.col = c("#E6E6FA", "#B0C4DE"), # lavender and light steel blue
mark.border = NA)
dev.off()
You get the point ;)
ggraphThe basic ggraph() plot adds edges and nodes using layers. Here we start with a default layout and basic layers. Here you can find additional information on changeable parameters.
ggraph(twin_cities) +
geom_edge_link() + # Adds straight edges
geom_node_point() # Adds simple node pointsYou can customize the layout. Here we use "gem", a force-directed layout similar to Fruchterman-Reingold, which gives a more organic structure to the network. You can use different edge and node geometries for various effects. geom_edge_fan() helps visualize overlapping edges, and you can control their appearance with color, width, and transparency.
ggraph(twin_cities, layout = "gem") +
geom_edge_fan(size = 1, color = "lightgray") +
geom_node_point(size = 4, color = "lavender") +
ggtitle("Twin Cities Network (GEM Layout)") +
theme_void()
You can also use layouts like 'linear' to arrange nodes along a line, which is useful for timelines or flows. Here we use geom_edge_arc() to show curved connections.
Just like in ggplot2, you can map node or edge attributes to aesthetics using aes(). Below we color edges by a type attribute (if available) and scale node size
# Save high-resolution ggraph plot
p <- ggraph(twin_cities, layout = "linear") +
geom_edge_arc(color = "#6495ED", width = 0.6) +
geom_node_point(size = 1, color = "navy") +
geom_node_text(aes(label = name),
nudge_y = -0.6,
vjust = 1.5,
angle = 45,
size = 1,
color = "navy") +
theme_void()
# Save the plot
ggsave("Graphics/twin_cities_linear.png", plot = p,
width = 10, height = 6, dpi = 300, units = "in")
You can also label nodes using their names. Here we use geom_node_text() with repelling to avoid overlapping labels.
ggraph(twin_cities, layout = "fr") +
geom_edge_link(color = "gray80") +
geom_node_point(size = 5, color = "lavender") + # medium orchid
geom_node_text(aes(label = name), size = 3, color = "navy", repel = TRUE) +
theme_void()
The ggraph package automatically generates legends when aesthetics like color or size are mapped to attributes. This makes interpreting your network plots easier without manual legend handling.
# Create the network plot with ggraph
network_plot <- ggraph(twin_cities, layout = "fr") +
geom_edge_link(alpha = 0.4) +
geom_node_point(aes(color = countries), size = 2) +
theme_minimal() +
labs(title = "Twin Cities Network by Country") +
theme(
legend.position = "right", # Keeps the legend on the right
plot.margin = margin(r = 150), # Adds margin space for legend
legend.text = element_text(size = 3), # Smaller text for legend
legend.title = element_text(size = 2), # Smaller legend title text
legend.key.size = unit(0.5, "cm") # Smaller legend key size (color swatches)
)
# Arrange the plot with the adjusted legend size
grid.arrange(network_plot, ncol = 1)
# Convert the twin_cities network to an adjacency matrix (without edge weights, if not available)
netm <- as_adjacency_matrix(twin_cities, sparse = FALSE)
# Set the row and column names as the city names (or node names)
colnames(netm) <- V(twin_cities)$name
rownames(netm) <- V(twin_cities)$name
# Create a color palette for the heatmap
palf <- colorRampPalette(c("lavender", "lightblue"))
# Plot the heatmap
heatmap(netm,
Rowv = NA,
Colv = NA,
col = palf(100),
scale = "none",
margins = c(10, 10),
main = "Adjacency Matrix Heatmap of Twin Cities Network")# Calculate the degree distribution of the network
deg.dist <- degree_distribution(twin_cities, cumulative = TRUE, mode = "all")
# Plot the degree distribution
plot(x = 0:max(degree(twin_cities)),
y = 1 - deg.dist,
pch = 19,
cex = 1.2,
col = "lavender",
xlab = "Degree",
ylab = "Cumulative Frequency",
main = "Degree Distribution of Twin Cities Network")# Create a random network (Erdős–Rényi model)
set.seed(123) # For reproducibility
random_net <- erdos.renyi.game(20, p = 0.2, directed = FALSE) # 20 nodes, edge probability = 0.2
# Convert the random network to an adjacency matrix
netm <- as_adjacency_matrix(random_net, sparse = FALSE)
# Set row and column names as the node names (1, 2, ..., 20)
colnames(netm) <- V(random_net)$name
rownames(netm) <- V(random_net)$name
# Create a color palette for the heatmap
palf <- colorRampPalette(c("lavender", "lightblue"))
# Plot the heatmap of the adjacency matrix
heatmap(netm,
Rowv = NA,
Colv = NA,
col = palf(100),
scale = "none",
margins = c(10, 10),
main = "Adjacency Matrix Heatmap of Random Network")
# Calculate the degree distribution of the random network
deg.dist <- degree_distribution(random_net, cumulative = TRUE, mode = "all")
# Plot the degree distribution
plot(x = 0:max(degree(random_net)),
y = 1 - deg.dist,
pch = 19,
cex = 1.2,
col = "lavender",
xlab = "Degree",
ylab = "Cumulative Frequency",
main = "Degree Distribution of Random Network")
A lot of the times, networks are plottes as static networks at different timeframes
g <- twin_cities
start_node <- "Leipzig"
V(g)$dist <- distances(g, v = start_node)[1,]
g_t1 <- induced_subgraph(g, vids = V(g)[V(g)$name == start_node])
ggraph(g_t1, layout = "fr") +
geom_edge_link(color = "gray", alpha = 0.6) +
geom_node_point(color = "lavender", size = 6) +
geom_node_text(aes(label = name), vjust = -1, repel = TRUE, color = "darkblue") +
ggtitle("D = 0: Leipzig") +
theme_void() +
theme(plot.title = element_text(hjust = 0.5, size = 12))
# D = 1: Leipzig + Neighbors
g_t2 <- induced_subgraph(g, vids = V(g)[V(g)$dist <= 1])
ggraph(g_t2, layout = "fr") +
geom_edge_link(color = "gray", alpha = 0.6) +
geom_node_point(color = "lavender", size = 6) +
geom_node_text(aes(label = name), vjust = -1, repel = TRUE, color = "darkblue") +
ggtitle("D = 1: Leipzig + Neighbors") +
theme_void() +
theme(plot.title = element_text(hjust = 0.5, size = 12))
# D = 2: Leipzig + Neighbors of Neighbors
g_t3 <- induced_subgraph(g, vids = V(g)[V(g)$dist <= 2])
ggraph(g_t3, layout = "fr") +
geom_edge_link(color = "gray", alpha = 0.6) +
geom_node_point(color = "lavender", size = 6) +
geom_node_text(aes(label = name), vjust = -1, repel = TRUE, color = "darkblue") +
ggtitle("D = 2: Leipzig + Neighbors of Neighbors") +
theme_void() +
theme(plot.title = element_text(hjust = 0.5, size = 12))
# Set the starting node (Leipzig)
start_node <- "Leipzig"
# Calculate distance from Leipzig for all nodes
distances_from_leipzig <- distances(g, v = start_node)[1,]
V(g)$distance <- distances_from_leipzig # Store the distances as a vertex attribute
# Create a list of graphs for each distance level (time)
max_dist <- max(V(g)$distance, na.rm = TRUE) # Maximum distance
# Create a list to store subgraphs at each time step
subgraphs <- lapply(0:max_dist, function(d) {
# Create a subgraph that includes nodes with distance <= d
nodes_in_time <- V(g)[V(g)$distance <= d]
induced_subgraph(g, vids = nodes_in_time)
})
# Create an animated plot using ggraph
p <- ggraph(g, layout = "fr") +
geom_edge_link(aes(alpha = 0.3), show.legend = FALSE) +
geom_node_point(aes(color = distance), size = 5) +
geom_node_text(aes(label = name), vjust = -1) +
transition_states(V(g)$distance, transition_length = 1, state_length = 100) +
labs(title = "Twin City Growth from Leipzig: t = {closest_state}") +
ease_aes('cubic-in-out')
# Animate the graph over time
animation <- animate(p, nframes = (max_dist + 1) * 10, width = 800, height = 600)
anim_save("Graphics/twin_city_growth.gif", animation = animation)
or we can just create a shiny-App with a slider
library(shiny)
ui <- fluidPage(
sliderInput("t", "Time Step", min = 0, max = 2, value = 0, step = 1),
plotOutput("networkPlot")
)
server <- function(input, output, session) {
output$networkPlot <- renderPlot({
vids <- V(g)[V(g)$dist <= input$t]
g_sub <- induced_subgraph(g, vids = vids)
ggraph(g_sub, layout = "fr") +
geom_edge_link(aes(alpha = 0.3), show.legend = FALSE) +
geom_node_point(aes(color = distance), size = 5) +
geom_node_text(aes(label = name), vjust = -1) +
ggtitle(paste("Network at time =", input$t))
})
}
shinyApp(ui, server)networkD3To create an interactive network visualization with networkD3, you first need to convert your igraph network into two data frames: one for nodes and one for edges (links). The nodes should include a unique id and optionally attributes like group or size, while the links should include source and target indices starting from 0 (not 1).
Once the data is prepared, use forceNetwork() to build the visualization, specifying node and edge attributes, and finally save it as an HTML file using htmlwidgets::saveWidget(). This allows zooming, dragging, and exploring the network interactively in a browser.
# Extract links and nodes for visualization
links <- as.data.frame(get.edgelist(twin_cities))
nodes <- data.frame(
id = 1:vcount(twin_cities),
name = V(twin_cities)$name,
countries = V(twin_cities)$countries
)
# Ensure node IDs are numeric and start from 0
links.d3 <- data.frame(from = as.numeric(factor(links$V1)) - 1,
to = as.numeric(factor(links$V2)) - 1)
# Add a Nodesize column (you can use an actual attribute here, like degree, if needed)
nodes.d3 <- data.frame(idn = factor(nodes$name, levels = nodes$name), nodes)
nodes.d3$Nodesize <- rep(6, nrow(nodes.d3)) # Add a constant size for each node
# Save as a standalone HTML file
htmlwidgets::saveWidget(
forceNetwork(Links = links.d3, Nodes = nodes.d3, Source = "from", Target = "to",
NodeID = "name", Group = "countries", linkWidth = 1,
linkColour = "#afafaf", fontSize = 12, zoom = TRUE, legend = FALSE,
Nodesize = "Nodesize", opacity = 0.8, charge = -300,
width = 800, height = 600),
"Graphics/network_plot_interactive.html", selfcontained = TRUE
)The Bali-network shows the interactions inside the Jemaah Ismlamiyah terrorist group, which conducted an attack in Bali in the year of 2002.
You can load the network like this:
library(intergraph)
#install.packages("devtools")
#devtools::install_github("DougLuke/UserNetR")
library(UserNetR)
data(Bali)
Bali <- asIgraph(Bali)
help(Bali)The network consists of 17 nodes (the terrorists) and 63 edges (their interactions). Next to the names, their roles in the group are saved as node attributes. The intensity of the interaction is saved as an edge attribute (See help(Bali)).
Plot the network so that the role is displayed as the node label. You can also change the size of the node
Define the color for each node, so that the color resembles the respective role.
Change the shape of the Commanders (CT) to a rectangle.
Use the edge attribute IC, so that an edge is thicker if there is higher interaction between terrorists.
Create an interactive plot, where, when you hover over the node, the role is shown.